home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / lib / python2.6 / threading.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-11-11  |  27.0 KB  |  947 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. """Thread module emulating a subset of Java's threading model."""
  5. import sys as _sys
  6.  
  7. try:
  8.     import thread
  9. except ImportError:
  10.     del _sys.modules[__name__]
  11.     raise 
  12.  
  13. import warnings
  14. from functools import wraps
  15. from time import time as _time, sleep as _sleep
  16. from traceback import format_exc as _format_exc
  17. from collections import deque
  18. __all__ = [
  19.     'activeCount',
  20.     'active_count',
  21.     'Condition',
  22.     'currentThread',
  23.     'current_thread',
  24.     'enumerate',
  25.     'Event',
  26.     'Lock',
  27.     'RLock',
  28.     'Semaphore',
  29.     'BoundedSemaphore',
  30.     'Thread',
  31.     'Timer',
  32.     'setprofile',
  33.     'settrace',
  34.     'local',
  35.     'stack_size']
  36. _start_new_thread = thread.start_new_thread
  37. _allocate_lock = thread.allocate_lock
  38. _get_ident = thread.get_ident
  39. ThreadError = thread.error
  40. del thread
  41. warnings.filterwarnings('ignore', category = DeprecationWarning, module = 'threading', message = 'sys.exc_clear')
  42. _VERBOSE = False
  43.  
  44. class _Verbose(object):
  45.     
  46.     def __init__(self, verbose = None):
  47.         if verbose is None:
  48.             verbose = _VERBOSE
  49.         
  50.         self._Verbose__verbose = verbose
  51.  
  52.     
  53.     def _note(self, format, *args):
  54.         if self._Verbose__verbose:
  55.             format = format % args
  56.             format = '%s: %s\n' % (current_thread().name, format)
  57.             _sys.stderr.write(format)
  58.         
  59.  
  60.  
  61. _profile_hook = None
  62. _trace_hook = None
  63.  
  64. def setprofile(func):
  65.     global _profile_hook
  66.     _profile_hook = func
  67.  
  68.  
  69. def settrace(func):
  70.     global _trace_hook
  71.     _trace_hook = func
  72.  
  73. Lock = _allocate_lock
  74.  
  75. def RLock(*args, **kwargs):
  76.     return _RLock(*args, **kwargs)
  77.  
  78.  
  79. class _RLock(_Verbose):
  80.     
  81.     def __init__(self, verbose = None):
  82.         _Verbose.__init__(self, verbose)
  83.         self._RLock__block = _allocate_lock()
  84.         self._RLock__owner = None
  85.         self._RLock__count = 0
  86.  
  87.     
  88.     def __repr__(self):
  89.         owner = self._RLock__owner
  90.         if owner:
  91.             pass
  92.         return '<%s(%s, %d)>' % (self.__class__.__name__, owner.name, self._RLock__count)
  93.  
  94.     
  95.     def acquire(self, blocking = 1):
  96.         me = current_thread()
  97.         if self._RLock__owner is me:
  98.             self._RLock__count = self._RLock__count + 1
  99.             self._note('%s.acquire(%s): recursive success', self, blocking)
  100.             return 1
  101.         rc = self._RLock__block.acquire(blocking)
  102.         if rc:
  103.             self._RLock__owner = me
  104.             self._RLock__count = 1
  105.             self._note('%s.acquire(%s): initial success', self, blocking)
  106.         else:
  107.             self._note('%s.acquire(%s): failure', self, blocking)
  108.         return rc
  109.  
  110.     __enter__ = acquire
  111.     
  112.     def release(self):
  113.         if self._RLock__owner is not current_thread():
  114.             raise RuntimeError('cannot release un-aquired lock')
  115.         self._RLock__owner is not current_thread()
  116.         self._RLock__count = count = self._RLock__count - 1
  117.         if not count:
  118.             self._RLock__owner = None
  119.             self._RLock__block.release()
  120.             self._note('%s.release(): final release', self)
  121.         else:
  122.             self._note('%s.release(): non-final release', self)
  123.  
  124.     
  125.     def __exit__(self, t, v, tb):
  126.         self.release()
  127.  
  128.     
  129.     def _acquire_restore(self, count_owner):
  130.         (count, owner) = count_owner
  131.         self._RLock__block.acquire()
  132.         self._RLock__count = count
  133.         self._RLock__owner = owner
  134.         self._note('%s._acquire_restore()', self)
  135.  
  136.     
  137.     def _release_save(self):
  138.         self._note('%s._release_save()', self)
  139.         count = self._RLock__count
  140.         self._RLock__count = 0
  141.         owner = self._RLock__owner
  142.         self._RLock__owner = None
  143.         self._RLock__block.release()
  144.         return (count, owner)
  145.  
  146.     
  147.     def _is_owned(self):
  148.         return self._RLock__owner is current_thread()
  149.  
  150.  
  151.  
  152. def Condition(*args, **kwargs):
  153.     return _Condition(*args, **kwargs)
  154.  
  155.  
  156. class _Condition(_Verbose):
  157.     
  158.     def __init__(self, lock = None, verbose = None):
  159.         _Verbose.__init__(self, verbose)
  160.         if lock is None:
  161.             lock = RLock()
  162.         
  163.         self._Condition__lock = lock
  164.         self.acquire = lock.acquire
  165.         self.release = lock.release
  166.         
  167.         try:
  168.             self._release_save = lock._release_save
  169.         except AttributeError:
  170.             pass
  171.  
  172.         
  173.         try:
  174.             self._acquire_restore = lock._acquire_restore
  175.         except AttributeError:
  176.             pass
  177.  
  178.         
  179.         try:
  180.             self._is_owned = lock._is_owned
  181.         except AttributeError:
  182.             pass
  183.  
  184.         self._Condition__waiters = []
  185.  
  186.     
  187.     def __enter__(self):
  188.         return self._Condition__lock.__enter__()
  189.  
  190.     
  191.     def __exit__(self, *args):
  192.         return self._Condition__lock.__exit__(*args)
  193.  
  194.     
  195.     def __repr__(self):
  196.         return '<Condition(%s, %d)>' % (self._Condition__lock, len(self._Condition__waiters))
  197.  
  198.     
  199.     def _release_save(self):
  200.         self._Condition__lock.release()
  201.  
  202.     
  203.     def _acquire_restore(self, x):
  204.         self._Condition__lock.acquire()
  205.  
  206.     
  207.     def _is_owned(self):
  208.         if self._Condition__lock.acquire(0):
  209.             self._Condition__lock.release()
  210.             return False
  211.         return True
  212.  
  213.     
  214.     def wait(self, timeout = None):
  215.         if not self._is_owned():
  216.             raise RuntimeError('cannot wait on un-aquired lock')
  217.         self._is_owned()
  218.         waiter = _allocate_lock()
  219.         waiter.acquire()
  220.         self._Condition__waiters.append(waiter)
  221.         saved_state = self._release_save()
  222.         
  223.         try:
  224.             if timeout is None:
  225.                 waiter.acquire()
  226.                 self._note('%s.wait(): got it', self)
  227.             else:
  228.                 endtime = _time() + timeout
  229.                 delay = 0.0005
  230.                 while True:
  231.                     gotit = waiter.acquire(0)
  232.                     if gotit:
  233.                         break
  234.                     
  235.                     remaining = endtime - _time()
  236.                     if remaining <= 0:
  237.                         break
  238.                     
  239.                     delay = min(delay * 2, remaining, 0.05)
  240.                     _sleep(delay)
  241.                 if not gotit:
  242.                     self._note('%s.wait(%s): timed out', self, timeout)
  243.                     
  244.                     try:
  245.                         self._Condition__waiters.remove(waiter)
  246.                     except ValueError:
  247.                         pass
  248.                     except:
  249.                         None<EXCEPTION MATCH>ValueError
  250.                     
  251.  
  252.                 None<EXCEPTION MATCH>ValueError
  253.                 self._note('%s.wait(%s): got it', self, timeout)
  254.         finally:
  255.             self._acquire_restore(saved_state)
  256.  
  257.  
  258.     
  259.     def notify(self, n = 1):
  260.         if not self._is_owned():
  261.             raise RuntimeError('cannot notify on un-aquired lock')
  262.         self._is_owned()
  263.         _Condition__waiters = self._Condition__waiters
  264.         waiters = _Condition__waiters[:n]
  265.         if not waiters:
  266.             self._note('%s.notify(): no waiters', self)
  267.             return None
  268.         if not n != 1 or 's':
  269.             pass
  270.         self._note('%s.notify(): notifying %d waiter%s', self, n, '')
  271.         for waiter in waiters:
  272.             waiter.release()
  273.             
  274.             try:
  275.                 _Condition__waiters.remove(waiter)
  276.             continue
  277.             except ValueError:
  278.                 waiters
  279.                 waiters
  280.                 continue
  281.             
  282.  
  283.         
  284.  
  285.     
  286.     def notifyAll(self):
  287.         self.notify(len(self._Condition__waiters))
  288.  
  289.     notify_all = notifyAll
  290.  
  291.  
  292. def Semaphore(*args, **kwargs):
  293.     return _Semaphore(*args, **kwargs)
  294.  
  295.  
  296. class _Semaphore(_Verbose):
  297.     
  298.     def __init__(self, value = 1, verbose = None):
  299.         if value < 0:
  300.             raise ValueError('semaphore initial value must be >= 0')
  301.         value < 0
  302.         _Verbose.__init__(self, verbose)
  303.         self._Semaphore__cond = Condition(Lock())
  304.         self._Semaphore__value = value
  305.  
  306.     
  307.     def acquire(self, blocking = 1):
  308.         rc = False
  309.         self._Semaphore__cond.acquire()
  310.         while self._Semaphore__value == 0:
  311.             if not blocking:
  312.                 break
  313.             
  314.             self._note('%s.acquire(%s): blocked waiting, value=%s', self, blocking, self._Semaphore__value)
  315.             self._Semaphore__cond.wait()
  316.         self._Semaphore__value = self._Semaphore__value - 1
  317.         self._note('%s.acquire: success, value=%s', self, self._Semaphore__value)
  318.         rc = True
  319.         self._Semaphore__cond.release()
  320.         return rc
  321.  
  322.     __enter__ = acquire
  323.     
  324.     def release(self):
  325.         self._Semaphore__cond.acquire()
  326.         self._Semaphore__value = self._Semaphore__value + 1
  327.         self._note('%s.release: success, value=%s', self, self._Semaphore__value)
  328.         self._Semaphore__cond.notify()
  329.         self._Semaphore__cond.release()
  330.  
  331.     
  332.     def __exit__(self, t, v, tb):
  333.         self.release()
  334.  
  335.  
  336.  
  337. def BoundedSemaphore(*args, **kwargs):
  338.     return _BoundedSemaphore(*args, **kwargs)
  339.  
  340.  
  341. class _BoundedSemaphore(_Semaphore):
  342.     '''Semaphore that checks that # releases is <= # acquires'''
  343.     
  344.     def __init__(self, value = 1, verbose = None):
  345.         _Semaphore.__init__(self, value, verbose)
  346.         self._initial_value = value
  347.  
  348.     
  349.     def release(self):
  350.         if self._Semaphore__value >= self._initial_value:
  351.             raise ValueError, 'Semaphore released too many times'
  352.         self._Semaphore__value >= self._initial_value
  353.         return _Semaphore.release(self)
  354.  
  355.  
  356.  
  357. def Event(*args, **kwargs):
  358.     return _Event(*args, **kwargs)
  359.  
  360.  
  361. class _Event(_Verbose):
  362.     
  363.     def __init__(self, verbose = None):
  364.         _Verbose.__init__(self, verbose)
  365.         self._Event__cond = Condition(Lock())
  366.         self._Event__flag = False
  367.  
  368.     
  369.     def isSet(self):
  370.         return self._Event__flag
  371.  
  372.     is_set = isSet
  373.     
  374.     def set(self):
  375.         self._Event__cond.acquire()
  376.         
  377.         try:
  378.             self._Event__flag = True
  379.             self._Event__cond.notify_all()
  380.         finally:
  381.             self._Event__cond.release()
  382.  
  383.  
  384.     
  385.     def clear(self):
  386.         self._Event__cond.acquire()
  387.         
  388.         try:
  389.             self._Event__flag = False
  390.         finally:
  391.             self._Event__cond.release()
  392.  
  393.  
  394.     
  395.     def wait(self, timeout = None):
  396.         self._Event__cond.acquire()
  397.         
  398.         try:
  399.             if not self._Event__flag:
  400.                 self._Event__cond.wait(timeout)
  401.         finally:
  402.             self._Event__cond.release()
  403.  
  404.  
  405.  
  406. _counter = 0
  407.  
  408. def _newname(template = 'Thread-%d'):
  409.     global _counter
  410.     _counter = _counter + 1
  411.     return template % _counter
  412.  
  413. _active_limbo_lock = _allocate_lock()
  414. _active = { }
  415. _limbo = { }
  416.  
  417. class Thread(_Verbose):
  418.     __initialized = False
  419.     __exc_info = _sys.exc_info
  420.     __exc_clear = _sys.exc_clear
  421.     
  422.     def __init__(self, group = None, target = None, name = None, args = (), kwargs = None, verbose = None):
  423.         if not group is None:
  424.             raise AssertionError, 'group argument must be None for now'
  425.         _Verbose.__init__(self, verbose)
  426.         if kwargs is None:
  427.             kwargs = { }
  428.         
  429.         self._Thread__target = target
  430.         if not name:
  431.             pass
  432.         self._Thread__name = str(_newname())
  433.         self._Thread__args = args
  434.         self._Thread__kwargs = kwargs
  435.         self._Thread__daemonic = self._set_daemon()
  436.         self._Thread__ident = None
  437.         self._Thread__started = Event()
  438.         self._Thread__stopped = False
  439.         self._Thread__block = Condition(Lock())
  440.         self._Thread__initialized = True
  441.         self._Thread__stderr = _sys.stderr
  442.  
  443.     
  444.     def _set_daemon(self):
  445.         return current_thread().daemon
  446.  
  447.     
  448.     def __repr__(self):
  449.         if not self._Thread__initialized:
  450.             raise AssertionError, 'Thread.__init__() was not called'
  451.         status = 'initial'
  452.         if self._Thread__started.is_set():
  453.             status = 'started'
  454.         
  455.         if self._Thread__stopped:
  456.             status = 'stopped'
  457.         
  458.         if self._Thread__daemonic:
  459.             status += ' daemon'
  460.         
  461.         if self._Thread__ident is not None:
  462.             status += ' %s' % self._Thread__ident
  463.         
  464.         return '<%s(%s, %s)>' % (self.__class__.__name__, self._Thread__name, status)
  465.  
  466.     
  467.     def start(self):
  468.         if not self._Thread__initialized:
  469.             raise RuntimeError('thread.__init__() not called')
  470.         self._Thread__initialized
  471.         if self._Thread__started.is_set():
  472.             raise RuntimeError('thread already started')
  473.         self._Thread__started.is_set()
  474.         self._note('%s.start(): starting thread', self)
  475.         _active_limbo_lock.acquire()
  476.         _limbo[self] = self
  477.         _active_limbo_lock.release()
  478.         _start_new_thread(self._Thread__bootstrap, ())
  479.         self._Thread__started.wait()
  480.  
  481.     
  482.     def run(self):
  483.         
  484.         try:
  485.             if self._Thread__target:
  486.                 self._Thread__target(*self._Thread__args, **self._Thread__kwargs)
  487.         finally:
  488.             del self._Thread__target
  489.             del self._Thread__args
  490.             del self._Thread__kwargs
  491.  
  492.  
  493.     
  494.     def __bootstrap(self):
  495.         
  496.         try:
  497.             self._Thread__bootstrap_inner()
  498.         except:
  499.             if self._Thread__daemonic and _sys is None:
  500.                 return None
  501.             raise 
  502.  
  503.  
  504.     
  505.     def _set_ident(self):
  506.         self._Thread__ident = _get_ident()
  507.  
  508.     
  509.     def __bootstrap_inner(self):
  510.         
  511.         try:
  512.             self._set_ident()
  513.             self._Thread__started.set()
  514.             _active_limbo_lock.acquire()
  515.             _active[self._Thread__ident] = self
  516.             del _limbo[self]
  517.             _active_limbo_lock.release()
  518.             self._note('%s.__bootstrap(): thread started', self)
  519.             if _trace_hook:
  520.                 self._note('%s.__bootstrap(): registering trace hook', self)
  521.                 _sys.settrace(_trace_hook)
  522.             
  523.             if _profile_hook:
  524.                 self._note('%s.__bootstrap(): registering profile hook', self)
  525.                 _sys.setprofile(_profile_hook)
  526.             
  527.             
  528.             try:
  529.                 self.run()
  530.             except SystemExit:
  531.                 self._note('%s.__bootstrap(): raised SystemExit', self)
  532.             except:
  533.                 self._note('%s.__bootstrap(): unhandled exception', self)
  534.                 if _sys:
  535.                     _sys.stderr.write('Exception in thread %s:\n%s\n' % (self.name, _format_exc()))
  536.                 else:
  537.                     (exc_type, exc_value, exc_tb) = self._Thread__exc_info()
  538.                     
  539.                     try:
  540.                         print >>self._Thread__stderr, 'Exception in thread ' + self.name + ' (most likely raised during interpreter shutdown):'
  541.                         print >>self._Thread__stderr, 'Traceback (most recent call last):'
  542.                         while exc_tb:
  543.                             print >>self._Thread__stderr, '  File "%s", line %s, in %s' % (exc_tb.tb_frame.f_code.co_filename, exc_tb.tb_lineno, exc_tb.tb_frame.f_code.co_name)
  544.                             exc_tb = exc_tb.tb_next
  545.                         print >>self._Thread__stderr, '%s: %s' % (exc_type, exc_value)
  546.                     finally:
  547.                         del exc_type
  548.                         del exc_value
  549.                         del exc_tb
  550.  
  551.             else:
  552.                 self._note('%s.__bootstrap(): normal return', self)
  553.             finally:
  554.                 self._Thread__exc_clear()
  555.  
  556.         finally:
  557.             _active_limbo_lock.__enter__()
  558.             
  559.             try:
  560.                 self._Thread__stop()
  561.                 
  562.                 try:
  563.                     del _active[_get_ident()]
  564.                 except:
  565.                     _active_limbo_lock.__exit__
  566.                     _active_limbo_lock
  567.  
  568.             finally:
  569.                 pass
  570.  
  571.  
  572.  
  573.     
  574.     def __stop(self):
  575.         self._Thread__block.acquire()
  576.         self._Thread__stopped = True
  577.         self._Thread__block.notify_all()
  578.         self._Thread__block.release()
  579.  
  580.     
  581.     def __delete(self):
  582.         '''Remove current thread from the dict of currently running threads.'''
  583.         
  584.         try:
  585.             _active_limbo_lock.__enter__()
  586.             
  587.             try:
  588.                 del _active[_get_ident()]
  589.             finally:
  590.                 pass
  591.  
  592.         except KeyError:
  593.             if 'dummy_threading' not in _sys.modules:
  594.                 raise 
  595.             'dummy_threading' not in _sys.modules
  596.  
  597.  
  598.     
  599.     def join(self, timeout = None):
  600.         if not self._Thread__initialized:
  601.             raise RuntimeError('Thread.__init__() not called')
  602.         self._Thread__initialized
  603.         if not self._Thread__started.is_set():
  604.             raise RuntimeError('cannot join thread before it is started')
  605.         self._Thread__started.is_set()
  606.         if self is current_thread():
  607.             raise RuntimeError('cannot join current thread')
  608.         self is current_thread()
  609.         if not self._Thread__stopped:
  610.             self._note('%s.join(): waiting until thread stops', self)
  611.         
  612.         self._Thread__block.acquire()
  613.         
  614.         try:
  615.             if timeout is None:
  616.                 while not self._Thread__stopped:
  617.                     self._Thread__block.wait()
  618.                 self._note('%s.join(): thread stopped', self)
  619.             else:
  620.                 deadline = _time() + timeout
  621.                 while not self._Thread__stopped:
  622.                     delay = deadline - _time()
  623.                     if delay <= 0:
  624.                         self._note('%s.join(): timed out', self)
  625.                         break
  626.                     
  627.                     self._Thread__block.wait(delay)
  628.                 self._note('%s.join(): thread stopped', self)
  629.         finally:
  630.             self._Thread__block.release()
  631.  
  632.  
  633.     
  634.     def name(self):
  635.         if not self._Thread__initialized:
  636.             raise AssertionError, 'Thread.__init__() not called'
  637.         return self._Thread__name
  638.  
  639.     name = property(name)
  640.     
  641.     def name(self, name):
  642.         if not self._Thread__initialized:
  643.             raise AssertionError, 'Thread.__init__() not called'
  644.         self._Thread__name = str(name)
  645.  
  646.     name = name.setter(name)
  647.     
  648.     def ident(self):
  649.         if not self._Thread__initialized:
  650.             raise AssertionError, 'Thread.__init__() not called'
  651.         return self._Thread__ident
  652.  
  653.     ident = property(ident)
  654.     
  655.     def isAlive(self):
  656.         if not self._Thread__initialized:
  657.             raise AssertionError, 'Thread.__init__() not called'
  658.         if self._Thread__started.is_set():
  659.             pass
  660.         return not (self._Thread__stopped)
  661.  
  662.     is_alive = isAlive
  663.     
  664.     def daemon(self):
  665.         if not self._Thread__initialized:
  666.             raise AssertionError, 'Thread.__init__() not called'
  667.         return self._Thread__daemonic
  668.  
  669.     daemon = property(daemon)
  670.     
  671.     def daemon(self, daemonic):
  672.         if not self._Thread__initialized:
  673.             raise RuntimeError('Thread.__init__() not called')
  674.         self._Thread__initialized
  675.         if self._Thread__started.is_set():
  676.             raise RuntimeError('cannot set daemon status of active thread')
  677.         self._Thread__started.is_set()
  678.         self._Thread__daemonic = daemonic
  679.  
  680.     daemon = daemon.setter(daemon)
  681.     
  682.     def isDaemon(self):
  683.         return self.daemon
  684.  
  685.     
  686.     def setDaemon(self, daemonic):
  687.         self.daemon = daemonic
  688.  
  689.     
  690.     def getName(self):
  691.         return self.name
  692.  
  693.     
  694.     def setName(self, name):
  695.         self.name = name
  696.  
  697.  
  698.  
  699. def Timer(*args, **kwargs):
  700.     return _Timer(*args, **kwargs)
  701.  
  702.  
  703. class _Timer(Thread):
  704.     """Call a function after a specified number of seconds:
  705.  
  706.     t = Timer(30.0, f, args=[], kwargs={})
  707.     t.start()
  708.     t.cancel() # stop the timer's action if it's still waiting
  709.     """
  710.     
  711.     def __init__(self, interval, function, args = [], kwargs = { }):
  712.         Thread.__init__(self)
  713.         self.interval = interval
  714.         self.function = function
  715.         self.args = args
  716.         self.kwargs = kwargs
  717.         self.finished = Event()
  718.  
  719.     
  720.     def cancel(self):
  721.         """Stop the timer if it hasn't finished yet"""
  722.         self.finished.set()
  723.  
  724.     
  725.     def run(self):
  726.         self.finished.wait(self.interval)
  727.         if not self.finished.is_set():
  728.             self.function(*self.args, **self.kwargs)
  729.         
  730.         self.finished.set()
  731.  
  732.  
  733.  
  734. class _MainThread(Thread):
  735.     
  736.     def __init__(self):
  737.         Thread.__init__(self, name = 'MainThread')
  738.         self._Thread__started.set()
  739.         self._set_ident()
  740.         _active_limbo_lock.acquire()
  741.         _active[_get_ident()] = self
  742.         _active_limbo_lock.release()
  743.  
  744.     
  745.     def _set_daemon(self):
  746.         return False
  747.  
  748.     
  749.     def _exitfunc(self):
  750.         self._Thread__stop()
  751.         t = _pickSomeNonDaemonThread()
  752.         if t:
  753.             self._note('%s: waiting for other threads', self)
  754.         
  755.         while t:
  756.             t.join()
  757.             t = _pickSomeNonDaemonThread()
  758.         self._note('%s: exiting', self)
  759.         self._Thread__delete()
  760.  
  761.  
  762.  
  763. def _pickSomeNonDaemonThread():
  764.     for t in enumerate():
  765.         if not (t.daemon) and t.is_alive():
  766.             return t
  767.     
  768.  
  769.  
  770. class _DummyThread(Thread):
  771.     
  772.     def __init__(self):
  773.         Thread.__init__(self, name = _newname('Dummy-%d'))
  774.         del self._Thread__block
  775.         self._Thread__started.set()
  776.         self._set_ident()
  777.         _active_limbo_lock.acquire()
  778.         _active[_get_ident()] = self
  779.         _active_limbo_lock.release()
  780.  
  781.     
  782.     def _set_daemon(self):
  783.         return True
  784.  
  785.     
  786.     def join(self, timeout = None):
  787.         if not False:
  788.             raise AssertionError, 'cannot join a dummy thread'
  789.  
  790.  
  791.  
  792. def currentThread():
  793.     
  794.     try:
  795.         return _active[_get_ident()]
  796.     except KeyError:
  797.         return _DummyThread()
  798.  
  799.  
  800. current_thread = currentThread
  801.  
  802. def activeCount():
  803.     _active_limbo_lock.acquire()
  804.     count = len(_active) + len(_limbo)
  805.     _active_limbo_lock.release()
  806.     return count
  807.  
  808. active_count = activeCount
  809.  
  810. def enumerate():
  811.     _active_limbo_lock.acquire()
  812.     active = _active.values() + _limbo.values()
  813.     _active_limbo_lock.release()
  814.     return active
  815.  
  816. from thread import stack_size
  817. _shutdown = _MainThread()._exitfunc
  818.  
  819. try:
  820.     from thread import _local as local
  821. except ImportError:
  822.     from _threading_local import local
  823.  
  824.  
  825. def _after_fork():
  826.     global _active_limbo_lock
  827.     _active_limbo_lock = _allocate_lock()
  828.     new_active = { }
  829.     current = current_thread()
  830.     _active_limbo_lock.__enter__()
  831.     
  832.     try:
  833.         for thread in _active.itervalues():
  834.             if thread is current:
  835.                 ident = _get_ident()
  836.                 thread._Thread__ident = ident
  837.                 new_active[ident] = thread
  838.                 continue
  839.             _active_limbo_lock.__exit__
  840.             thread._Thread__stopped = True
  841.         
  842.         _limbo.clear()
  843.         _active.clear()
  844.         _active.update(new_active)
  845.         if not len(_active) == 1:
  846.             raise AssertionError
  847.     finally:
  848.         pass
  849.  
  850.  
  851.  
  852. def _test():
  853.     
  854.     class BoundedQueue(_Verbose):
  855.         
  856.         def __init__(self, limit):
  857.             _Verbose.__init__(self)
  858.             self.mon = RLock()
  859.             self.rc = Condition(self.mon)
  860.             self.wc = Condition(self.mon)
  861.             self.limit = limit
  862.             self.queue = deque()
  863.  
  864.         
  865.         def put(self, item):
  866.             self.mon.acquire()
  867.             while len(self.queue) >= self.limit:
  868.                 self._note('put(%s): queue full', item)
  869.                 self.wc.wait()
  870.             self.queue.append(item)
  871.             self._note('put(%s): appended, length now %d', item, len(self.queue))
  872.             self.rc.notify()
  873.             self.mon.release()
  874.  
  875.         
  876.         def get(self):
  877.             self.mon.acquire()
  878.             while not self.queue:
  879.                 self._note('get(): queue empty')
  880.                 self.rc.wait()
  881.             item = self.queue.popleft()
  882.             self._note('get(): got %s, %d left', item, len(self.queue))
  883.             self.wc.notify()
  884.             self.mon.release()
  885.             return item
  886.  
  887.  
  888.     
  889.     class ProducerThread(Thread):
  890.         
  891.         def __init__(self, queue, quota):
  892.             Thread.__init__(self, name = 'Producer')
  893.             self.queue = queue
  894.             self.quota = quota
  895.  
  896.         
  897.         def run(self):
  898.             random = random
  899.             import random
  900.             counter = 0
  901.             while counter < self.quota:
  902.                 counter = counter + 1
  903.                 self.queue.put('%s.%d' % (self.name, counter))
  904.                 _sleep(random() * 1e-05)
  905.  
  906.  
  907.     
  908.     class ConsumerThread(Thread):
  909.         
  910.         def __init__(self, queue, count):
  911.             Thread.__init__(self, name = 'Consumer')
  912.             self.queue = queue
  913.             self.count = count
  914.  
  915.         
  916.         def run(self):
  917.             while self.count > 0:
  918.                 item = self.queue.get()
  919.                 print item
  920.                 self.count = self.count - 1
  921.  
  922.  
  923.     NP = 3
  924.     QL = 4
  925.     NI = 5
  926.     Q = BoundedQueue(QL)
  927.     P = []
  928.     for i in range(NP):
  929.         t = ProducerThread(Q, NI)
  930.         t.name = 'Producer-%d' % (i + 1)
  931.         P.append(t)
  932.     
  933.     C = ConsumerThread(Q, NI * NP)
  934.     for t in P:
  935.         t.start()
  936.         _sleep(1e-06)
  937.     
  938.     C.start()
  939.     for t in P:
  940.         t.join()
  941.     
  942.     C.join()
  943.  
  944. if __name__ == '__main__':
  945.     _test()
  946.  
  947.